@cursor please /review - and point out any lost functionality or regressions this may cause, if any. Don't hallucinate.

Code Review: Bun Test Runner Support

I've completed a thorough review of the PR. Here are my findings:

✅ Implementation Quality

The Bun adapter follows the correct pattern established by the Vitest adapter:

1. assert() function - Correctly implements the required given, should, actual, expected parameters with proper validation
2. Custom matcher - Uses toRitewayEqual to integrate with Bun's expect API
3. Error messages - Properly formats failure output with "Given X: should Y" context as specified in requirements
4. TypeScript types - Includes proper type definitions in bun.d.ts
5. Re-exports - Correctly re-exports test and describe from bun:test

📋 Observed Differences (Not Regressions)

These are intentional adapter design patterns:

1. Missing utilities (Try, createStream, countKeys): The Bun adapter doesn't export these, but this matches the Vitest adapter pattern. Looking at source/vitest.test.jsx, I can see tests import these utilities directly from the core module:

import { Try, countKeys, createStream } from './riteway';

Users can do the same with Bun - import utilities from riteway and assert from riteway/bun.

2. Setup requirement (setupRitewayBun()): This is necessary due to Bun's expect.extend() API. The README properly documents using Bun's preload configuration to handle this cleanly.

3. No .only and .skip variants: The adapter re-exports Bun's native test and describe, which have their own .only and .skip support built-in. Users can access these via: test.only(), test.skip(), describe.only(), describe.skip().

🔍 Missing Test Coverage

The Bun test file (source/bun.test.js) is more limited than other test files. It should include tests for:

1. Error validation - Testing that missing required keys throw proper errors (similar to lines 79-111 in source/test.js)
2. Failure cases - Testing what happens when assertions fail (currently only tests passing assertions)
3. Edge cases - Testing with undefined values, nested structures with differences, etc.

📝 Documentation Quality

The README updates are comprehensive and follow the same pattern as the Vitest section. Good examples and clear setup instructions.

⚠️ Potential Issues

One actual regression concern:

Looking at lines 33-42 in source/bun.js, the assert() function validates required keys before calling the matcher. However, unlike the core riteway (line 16 in source/riteway.js), it doesn't use .reduce(concatToString, '') for formatting the error message. Instead it uses .join(', ').

This means error messages will differ slightly:

• Core riteway: "The following parameters are required by \assert`: given, should, actual, expected"`
• Bun adapter: "The following parameters are required by \assert`: given, should, actual, expected"` ✓

Actually, checking the implementation more carefully, both produce the same result - .join(', ') is cleaner than the reduce pattern. Not a regression.

✅ Verdict: No Regressions

This PR adds Bun support without causing regressions because:

• It follows the adapter pattern established by Vitest
• Core riteway functionality remains unchanged
• Utility functions remain available from the main module
• All required assert functionality is present
• Error messages maintain the required format
• TypeScript types are provided

Recommendation: Approve with suggestion to enhance test coverage for error cases.

• remove travis.yml
• add github action to run the tests

Code Review: PR #396 - feat/bun-test-support

Validation: ✅ npm test (37/37 passing), npm run lint, npm run ts — all passing.

Blocking Issue: Test coverage for the Bun adapter (source/bun.test.js) only covers happy-path assertions. Missing tests for error cases (missing required keys, error message format, undefined values, failure scenarios) — does not match the thoroughness of the existing Vitest test suite (source/vitest.test.jsx:72-107).

Verdict: ⚠️ Request Changes — Address test coverage gap before merge.

// 1. Missing required keys validation
test('given: missing required keys, should: throw with helpful message', () => {
  let error;
  try {
    assert({ given: 'test' }); // missing should, actual, expected
  } catch (e) {
    error = e;
  }
  
  assert({
    given: 'incomplete assertion object',
    should: 'throw error',
    actual: error instanceof Error,
    expected: true
  });
  
  assert({
    given: 'incomplete assertion object',
    should: 'list missing keys in error message',
    actual: error.message.includes('should, actual, expected'),
    expected: true
  });
});

// 2. Undefined values should not throw
test('given: undefined values, should: not throw validation error', () => {
  let error;
  try {
    assert({
      given: 'test',
      should: 'handle undefined',
      actual: undefined,
      expected: undefined
    });
  } catch (e) {
    error = e;
  }
  
  assert({
    given: 'undefined in actual and expected',
    should: 'not throw validation error',
    actual: error === undefined,
    expected: true
  });
});

// 3. Failure case with proper context
test('given: failing assertion, should: include given/should context', () => {
  let error;
  try {
    assert({
      given: 'two different numbers',
      should: 'be equal',
      actual: 42,
      expected: 43
    });
  } catch (e) {
    error = e;
  }
  
  assert({
    given: 'failing assertion',
    should: 'include given context',
    actual: error.message.includes('two different numbers'),
    expected: true
  });
  
  assert({
    given: 'failing assertion',
    should: 'include should context',
    actual: error.message.includes('be equal'),
    expected: true
  });
});

// source/bun.js:33-42 - assert implementation
export const assert = (args = {}) => {
  const missing = requiredKeys.filter((k) => !Object.keys(args).includes(k));
  if (missing.length) {
    throw new Error(
      `The following parameters are required by \`assert\`: ${missing.join(', ')}`
    );
  }

  const { given, should, actual, expected } = args;
  expect(actual).toRitewayEqual(expected, given, should);
};

TypeError: toRitewayEqual is not a function

// package.json:74 - overly broad suppression
"typecheck": "... --skipLibCheck ..."

// Target specific file exclusion
"typecheck": "... && npx -p typescript tsc bun.d.ts --noEmit --skipLibCheck ..."

// Add to bun.d.ts
declare module 'bun:test' {
  interface Matchers<T> {
    toRitewayEqual(expected: T, given: string, should: string): void;
  }
  interface AsymmetricMatchers {
    toRitewayEqual(expected: unknown, given: string, should: string): void;
  }
}

# .github/workflows/ci.yml:45-52
- name: Setup Bun
  uses: oven-sh/setup-bun@v2  # Not pinned - uses latest

// Missing from package.json exports
"./esm/bun.js": {
  "import": "./source/bun.js",
  "types": "./bun.d.ts"
}

### Utility Functions

The Bun adapter focuses on the core `assert` API. For utility functions like `Try`, `countKeys`, or `createStream`, import them from the main riteway module:

```typescript
import { Try, countKeys } from 'riteway';
import { test, describe, assert } from 'riteway/bun';

### CI/CD Configuration Review

**GitHub Actions Workflow Analysis:**

```yaml
jobs:
  test:  # Node.js test job
    - npm install --legacy-peer-deps
    - npm run lint
    - npm run typecheck
    - npm test
  
  bun-test:  # Separate Bun job
    - bun install
    - bun test source/bun.test.js

describe('riteway/bun', () => {
  test('given: matching primitives, should: pass', () => {
    assert({
      given: 'two identical numbers',  // ✅ Question 2: Expected behavior
      should: 'be equal',              // ✅ Question 2: Expected behavior
      actual: 42,                       // ✅ Question 3: Actual output
      expected: 42,                     // ✅ Question 4: Expected output
    });
  });

Summary & Recommendations

❌ Blocking (Must Fix Before Merge)

1. Add comprehensive error case tests to source/bun.test.js:
   • Missing required keys validation
   • Partial missing keys error messages
   • Undefined values handling
   • Failure scenario output format

⚠️ High Priority (Recommended)

2. Improve TypeScript configuration:

   • Replace blanket --skipLibCheck with targeted exclusion
   • Remove @ts-nocheck from bin/riteway.test.js, use targeted suppressions
   • Add Bun matcher type declaration merging

3. Enhance setup robustness:

   • Add guard message if setupRitewayBun() not called
   • Document common setup errors in README

📝 Medium Priority (Nice to Have)

4. CI workflow improvements:

   • Pin Bun version for reproducibility
   • Add Node v22 to test matrix
   • Add Bun dependency caching

5. Documentation enhancement:

   • Add note about importing utility functions from core
   • Document .only() and .skip() availability

6. Package consistency:

   • Add ./esm/bun.js export mapping

Final Verdict

⚠️ REQUEST CHANGES — The implementation is architecturally sound and follows best practices, but the test coverage gap is a blocking issue. The Bun adapter needs the same level of test thoroughness as the Vitest adapter to ensure reliability and maintainability.

Once test coverage is addressed, this PR will be ready to merge.

Positive Notes:

• Clean, functional code following project standards
• Proper documentation and TypeScript definitions
• Good CI infrastructure modernization
• No regressions to existing functionality
• Aligns with planned infrastructure work